/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.swing;

import java.awt.*;
import java.awt.event.*;
import java.awt.peer.ComponentPeer;
import java.beans.Transient;
import javax.swing.plaf.ViewportUI;

import javax.swing.event.*;
import javax.swing.border.*;
import javax.accessibility.*;

import java.io.Serializable;

/**
 * The "viewport" or "porthole" through which you see the underlying
 * information. When you scroll, what moves is the viewport. It is like
 * peering through a camera's viewfinder. Moving the viewfinder upwards
 * brings new things into view at the top of the picture and loses
 * things that were at the bottom.
 * <p>
 * By default, <code>JViewport</code> is opaque. To change this, use the
 * <code>setOpaque</code> method.
 * <p>
 * <b>NOTE:</b>We have implemented a faster scrolling algorithm that
 * does not require a buffer to draw in. The algorithm works as follows:
 * <ol><li>The view and parent view and checked to see if they are
 * <code>JComponents</code>,
 * if they aren't, stop and repaint the whole viewport.
 * <li>If the viewport is obscured by an ancestor, stop and repaint the whole
 * viewport.
 * <li>Compute the region that will become visible, if it is as big as
 * the viewport, stop and repaint the whole view region.
 * <li>Obtain the ancestor <code>Window</code>'s graphics and
 * do a <code>copyArea</code> on the scrolled region.
 * <li>Message the view to repaint the newly visible region.
 * <li>The next time paint is invoked on the viewport, if the clip region
 * is smaller than the viewport size a timer is kicked off to repaint the
 * whole region.
 * </ol>
 * In general this approach is much faster. Compared to the backing store
 * approach this avoids the overhead of maintaining an offscreen buffer and
 * having to do two <code>copyArea</code>s.
 * Compared to the non backing store case this
 * approach will greatly reduce the painted region.
 * <p>
 * This approach can cause slower times than the backing store approach
 * when the viewport is obscured by another window, or partially offscreen.
 * When another window
 * obscures the viewport the copyArea will copy garbage and a
 * paint event will be generated by the system to inform us we need to
 * paint the newly exposed region. The only way to handle this is to
 * repaint the whole viewport, which can cause slower performance than the
 * backing store case. In most applications very rarely will the user be
 * scrolling while the viewport is obscured by another window or offscreen,
 * so this optimization is usually worth the performance hit when obscured.
 * <p>
 * <strong>Warning:</strong> Swing is not thread safe. For more
 * information see <a
 * href="package-summary.html#threading">Swing's Threading
 * Policy</a>.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing.  As of 1.4, support for long term storage
 * of all JavaBeans&trade;
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @author Hans Muller
 * @author Philip Milne
 * @see JScrollPane
 */
public class JViewport extends JComponent implements Accessible {

  /**
   * @see #getUIClassID
   * @see #readObject
   */
  private static final String uiClassID = "ViewportUI";

  /**
   * Property used to indicate window blitting should not be done.
   */
  static final Object EnableWindowBlit = "EnableWindowBlit";

  /**
   * True when the viewport dimensions have been determined.
   * The default is false.
   */
  protected boolean isViewSizeSet = false;

  /**
   * The last <code>viewPosition</code> that we've painted, so we know how
   * much of the backing store image is valid.
   */
  protected Point lastPaintPosition = null;

  /**
   * True when this viewport is maintaining an offscreen image of its
   * contents, so that some scrolling can take place using fast "bit-blit"
   * operations instead of by accessing the view object to construct the
   * display.  The default is <code>false</code>.
   *
   * @see #setScrollMode
   * @deprecated As of Java 2 platform v1.3
   */
  @Deprecated
  protected boolean backingStore = false;

  /**
   * The view image used for a backing store.
   */
  transient protected Image backingStoreImage = null;

  /**
   * The <code>scrollUnderway</code> flag is used for components like
   * <code>JList</code>.  When the downarrow key is pressed on a
   * <code>JList</code> and the selected
   * cell is the last in the list, the <code>scrollpane</code> autoscrolls.
   * Here, the old selected cell needs repainting and so we need
   * a flag to make the viewport do the optimized painting
   * only when there is an explicit call to
   * <code>setViewPosition(Point)</code>.
   * When <code>setBounds</code> is called through other routes,
   * the flag is off and the view repaints normally.  Another approach
   * would be to remove this from the <code>JViewport</code>
   * class and have the <code>JList</code> manage this case by using
   * <code>setBackingStoreEnabled</code>.  The default is
   * <code>false</code>.
   */
  protected boolean scrollUnderway = false;

  /*
   * Listener that is notified each time the view changes size.
   */
  private ComponentListener viewListener = null;

  /* Only one <code>ChangeEvent</code> is needed per
   * <code>JViewport</code> instance since the
   * event's only (read-only) state is the source property.  The source
   * of events generated here is always "this".
   */
  private transient ChangeEvent changeEvent = null;

  /**
   * Use <code>graphics.copyArea</code> to implement scrolling.
   * This is the fastest for most applications.
   *
   * @see #setScrollMode
   * @since 1.3
   */
  public static final int BLIT_SCROLL_MODE = 1;

  /**
   * Draws viewport contents into an offscreen image.
   * This was previously the default mode for <code>JTable</code>.
   * This mode may offer advantages over "blit mode"
   * in some cases, but it requires a large chunk of extra RAM.
   *
   * @see #setScrollMode
   * @since 1.3
   */
  public static final int BACKINGSTORE_SCROLL_MODE = 2;

  /**
   * This mode uses the very simple method of redrawing the entire
   * contents of the scrollpane each time it is scrolled.
   * This was the default behavior in Swing 1.0 and Swing 1.1.
   * Either of the other two options will provide better performance
   * in most cases.
   *
   * @see #setScrollMode
   * @since 1.3
   */
  public static final int SIMPLE_SCROLL_MODE = 0;

  /**
   * @see #setScrollMode
   * @since 1.3
   */
  private int scrollMode = BLIT_SCROLL_MODE;

  //
  // Window blitting:
  //
  // As mentioned in the javadoc when using windowBlit a paint event
  // will be generated by the system if copyArea copies a non-visible
  // portion of the view (in other words, it copies garbage). We are
  // not guaranteed to receive the paint event before other mouse events,
  // so we can not be sure we haven't already copied garbage a bunch of
  // times to different parts of the view. For that reason when a blit
  // happens and the Component is obscured (the check for obscurity
  // is not supported on all platforms and is checked via ComponentPeer
  // methods) the ivar repaintAll is set to true. When paint is received
  // if repaintAll is true (we previously did a blit) it is set to
  // false, and if the clip region is smaller than the viewport
  // waitingForRepaint is set to true and a timer is started. When
  // the timer fires if waitingForRepaint is true, repaint is invoked.
  // In the mean time, if the view is asked to scroll and waitingForRepaint
  // is true, a blit will not happen, instead the non-backing store case
  // of scrolling will happen, which will reset waitingForRepaint.
  // waitingForRepaint is set to false in paint when the clip rect is
  // bigger (or equal) to the size of the viewport.
  // A Timer is used instead of just a repaint as it appeared to offer
  // better performance.


  /**
   * This is set to true in <code>setViewPosition</code>
   * if doing a window blit and the viewport is obscured.
   */
  private transient boolean repaintAll;

  /**
   * This is set to true in paint, if <code>repaintAll</code>
   * is true and the clip rectangle does not match the bounds.
   * If true, and scrolling happens the
   * repaint manager is not cleared which then allows for the repaint
   * previously invoked to succeed.
   */
  private transient boolean waitingForRepaint;

  /**
   * Instead of directly invoking repaint, a <code>Timer</code>
   * is started and when it fires, repaint is invoked.
   */
  private transient Timer repaintTimer;

  /**
   * Set to true in paintView when paint is invoked.
   */
  private transient boolean inBlitPaint;

  /**
   * Whether or not a valid view has been installed.
   */
  private boolean hasHadValidView;

  /**
   * When view is changed we have to synchronize scrollbar values
   * with viewport (see the BasicScrollPaneUI#syncScrollPaneWithViewport method).
   * This flag allows to invoke that method while ScrollPaneLayout#layoutContainer
   * is running.
   */
  private boolean viewChanged;

  /**
   * Creates a <code>JViewport</code>.
   */
  public JViewport() {
    super();
    setLayout(createLayoutManager());
    setOpaque(true);
    updateUI();
    setInheritsPopupMenu(true);
  }


  /**
   * Returns the L&amp;F object that renders this component.
   *
   * @return a <code>ViewportUI</code> object
   * @since 1.3
   */
  public ViewportUI getUI() {
    return (ViewportUI) ui;
  }


  /**
   * Sets the L&amp;F object that renders this component.
   *
   * @param ui the <code>ViewportUI</code> L&amp;F object
   * @beaninfo bound: true hidden: true attribute: visualUpdate true description: The UI object that
   * implements the Component's LookAndFeel.
   * @see UIDefaults#getUI
   * @since 1.3
   */
  public void setUI(ViewportUI ui) {
    super.setUI(ui);
  }


  /**
   * Resets the UI property to a value from the current look and feel.
   *
   * @see JComponent#updateUI
   */
  public void updateUI() {
    setUI((ViewportUI) UIManager.getUI(this));
  }


  /**
   * Returns a string that specifies the name of the L&amp;F class
   * that renders this component.
   *
   * @return the string "ViewportUI"
   * @see JComponent#getUIClassID
   * @see UIDefaults#getUI
   */
  public String getUIClassID() {
    return uiClassID;
  }


  /**
   * Sets the <code>JViewport</code>'s one lightweight child,
   * which can be <code>null</code>.
   * (Since there is only one child which occupies the entire viewport,
   * the <code>constraints</code> and <code>index</code>
   * arguments are ignored.)
   *
   * @param child the lightweight <code>child</code> of the viewport
   * @param constraints the <code>constraints</code> to be respected
   * @param index the index
   * @see #setView
   */
  protected void addImpl(Component child, Object constraints, int index) {
    setView(child);
  }


  /**
   * Removes the <code>Viewport</code>s one lightweight child.
   *
   * @see #setView
   */
  public void remove(Component child) {
    child.removeComponentListener(viewListener);
    super.remove(child);
  }

  /**
   * Scrolls the view so that <code>Rectangle</code>
   * within the view becomes visible.
   * <p>
   * This attempts to validate the view before scrolling if the
   * view is currently not valid - <code>isValid</code> returns false.
   * To avoid excessive validation when the containment hierarchy is
   * being created this will not validate if one of the ancestors does not
   * have a peer, or there is no validate root ancestor, or one of the
   * ancestors is not a <code>Window</code> or <code>Applet</code>.
   * <p>
   * Note that this method will not scroll outside of the
   * valid viewport; for example, if <code>contentRect</code> is larger
   * than the viewport, scrolling will be confined to the viewport's
   * bounds.
   *
   * @param contentRect the <code>Rectangle</code> to display
   * @see JComponent#isValidateRoot
   * @see java.awt.Component#isValid
   * @see java.awt.Component#getPeer
   */
  public void scrollRectToVisible(Rectangle contentRect) {
    Component view = getView();

    if (view == null) {
      return;
    } else {
      if (!view.isValid()) {
        // If the view is not valid, validate. scrollRectToVisible
        // may fail if the view is not valid first, contentRect
        // could be bigger than invalid size.
        validateView();
      }
      int dx, dy;

      dx = positionAdjustment(getWidth(), contentRect.width, contentRect.x);
      dy = positionAdjustment(getHeight(), contentRect.height, contentRect.y);

      if (dx != 0 || dy != 0) {
        Point viewPosition = getViewPosition();
        Dimension viewSize = view.getSize();
        int startX = viewPosition.x;
        int startY = viewPosition.y;
        Dimension extent = getExtentSize();

        viewPosition.x -= dx;
        viewPosition.y -= dy;
        // Only constrain the location if the view is valid. If the
        // the view isn't valid, it typically indicates the view
        // isn't visible yet and most likely has a bogus size as will
        // we, and therefore we shouldn't constrain the scrolling
        if (view.isValid()) {
          if (getParent().getComponentOrientation().isLeftToRight()) {
            if (viewPosition.x + extent.width > viewSize.width) {
              viewPosition.x = Math.max(0, viewSize.width - extent.width);
            } else if (viewPosition.x < 0) {
              viewPosition.x = 0;
            }
          } else {
            if (extent.width > viewSize.width) {
              viewPosition.x = viewSize.width - extent.width;
            } else {
              viewPosition.x = Math.max(0, Math.min(viewSize.width - extent.width, viewPosition.x));
            }
          }
          if (viewPosition.y + extent.height > viewSize.height) {
            viewPosition.y = Math.max(0, viewSize.height -
                extent.height);
          } else if (viewPosition.y < 0) {
            viewPosition.y = 0;
          }
        }
        if (viewPosition.x != startX || viewPosition.y != startY) {
          setViewPosition(viewPosition);
          // NOTE: How JViewport currently works with the
          // backing store is not foolproof. The sequence of
          // events when setViewPosition
          // (scrollRectToVisible) is called is to reset the
          // views bounds, which causes a repaint on the
          // visible region and sets an ivar indicating
          // scrolling (scrollUnderway). When
          // JViewport.paint is invoked if scrollUnderway is
          // true, the backing store is blitted.  This fails
          // if between the time setViewPosition is invoked
          // and paint is received another repaint is queued
          // indicating part of the view is invalid. There
          // is no way for JViewport to notice another
          // repaint has occurred and it ends up blitting
          // what is now a dirty region and the repaint is
          // never delivered.
          // It just so happens JTable encounters this
          // behavior by way of scrollRectToVisible, for
          // this reason scrollUnderway is set to false
          // here, which effectively disables the backing
          // store.
          scrollUnderway = false;
        }
      }
    }
  }

  /**
   * Ascends the <code>Viewport</code>'s parents stopping when
   * a component is found that returns
   * <code>true</code> to <code>isValidateRoot</code>.
   * If all the <code>Component</code>'s  parents are visible,
   * <code>validate</code> will then be invoked on it. The
   * <code>RepaintManager</code> is then invoked with
   * <code>removeInvalidComponent</code>. This
   * is the synchronous version of a <code>revalidate</code>.
   */
  private void validateView() {
    Component validateRoot = SwingUtilities.getValidateRoot(this, false);

    if (validateRoot == null) {
      return;
    }

    // Validate the root.
    validateRoot.validate();

    // And let the RepaintManager it does not have to validate from
    // validateRoot anymore.
    RepaintManager rm = RepaintManager.currentManager(this);

    if (rm != null) {
      rm.removeInvalidComponent((JComponent) validateRoot);
    }
  }

  /*  Used by the scrollRectToVisible method to determine the
   *  proper direction and amount to move by. The integer variables are named
   *  width, but this method is applicable to height also. The code assumes that
   *  parentWidth/childWidth are positive and childAt can be negative.
   */
  private int positionAdjustment(int parentWidth, int childWidth, int childAt) {

    //   +-----+
    //   | --- |     No Change
    //   +-----+
    if (childAt >= 0 && childWidth + childAt <= parentWidth) {
      return 0;
    }

    //   +-----+
    //  ---------   No Change
    //   +-----+
    if (childAt <= 0 && childWidth + childAt >= parentWidth) {
      return 0;
    }

    //   +-----+          +-----+
    //   |   ----    ->   | ----|
    //   +-----+          +-----+
    if (childAt > 0 && childWidth <= parentWidth) {
      return -childAt + parentWidth - childWidth;
    }

    //   +-----+             +-----+
    //   |  --------  ->     |--------
    //   +-----+             +-----+
    if (childAt >= 0 && childWidth >= parentWidth) {
      return -childAt;
    }

    //   +-----+          +-----+
    // ----    |     ->   |---- |
    //   +-----+          +-----+
    if (childAt <= 0 && childWidth <= parentWidth) {
      return -childAt;
    }

    //   +-----+             +-----+
    //-------- |      ->   --------|
    //   +-----+             +-----+
    if (childAt < 0 && childWidth >= parentWidth) {
      return -childAt + parentWidth - childWidth;
    }

    return 0;
  }


  /**
   * The viewport "scrolls" its child (called the "view") by the
   * normal parent/child clipping (typically the view is moved in
   * the opposite direction of the scroll).  A non-<code>null</code> border,
   * or non-zero insets, isn't supported, to prevent the geometry
   * of this component from becoming complex enough to inhibit
   * subclassing.  To create a <code>JViewport</code> with a border,
   * add it to a <code>JPanel</code> that has a border.
   * <p>Note:  If <code>border</code> is non-<code>null</code>, this
   * method will throw an exception as borders are not supported on
   * a <code>JViewPort</code>.
   *
   * @param border the <code>Border</code> to set
   * @throws IllegalArgumentException this method is not implemented
   */
  public final void setBorder(Border border) {
    if (border != null) {
      throw new IllegalArgumentException("JViewport.setBorder() not supported");
    }
  }


  /**
   * Returns the insets (border) dimensions as (0,0,0,0), since borders
   * are not supported on a <code>JViewport</code>.
   *
   * @return a <code>Rectangle</code> of zero dimension and zero origin
   * @see #setBorder
   */
  public final Insets getInsets() {
    return new Insets(0, 0, 0, 0);
  }

  /**
   * Returns an <code>Insets</code> object containing this
   * <code>JViewport</code>s inset values.  The passed-in
   * <code>Insets</code> object will be reinitialized, and
   * all existing values within this object are overwritten.
   *
   * @param insets the <code>Insets</code> object which can be reused
   * @return this viewports inset values
   * @beaninfo expert: true
   * @see #getInsets
   */
  public final Insets getInsets(Insets insets) {
    insets.left = insets.top = insets.right = insets.bottom = 0;
    return insets;
  }


  private Graphics getBackingStoreGraphics(Graphics g) {
    Graphics bsg = backingStoreImage.getGraphics();
    bsg.setColor(g.getColor());
    bsg.setFont(g.getFont());
    bsg.setClip(g.getClipBounds());
    return bsg;
  }


  private void paintViaBackingStore(Graphics g) {
    Graphics bsg = getBackingStoreGraphics(g);
    try {
      super.paint(bsg);
      g.drawImage(backingStoreImage, 0, 0, this);
    } finally {
      bsg.dispose();
    }
  }

  private void paintViaBackingStore(Graphics g, Rectangle oClip) {
    Graphics bsg = getBackingStoreGraphics(g);
    try {
      super.paint(bsg);
      g.setClip(oClip);
      g.drawImage(backingStoreImage, 0, 0, this);
    } finally {
      bsg.dispose();
    }
  }

  /**
   * The <code>JViewport</code> overrides the default implementation of
   * this method (in <code>JComponent</code>) to return false.
   * This ensures
   * that the drawing machinery will call the <code>Viewport</code>'s
   * <code>paint</code>
   * implementation rather than messaging the <code>JViewport</code>'s
   * children directly.
   *
   * @return false
   */
  public boolean isOptimizedDrawingEnabled() {
    return false;
  }

  /**
   * Returns true if scroll mode is a {@code BACKINGSTORE_SCROLL_MODE} to cause
   * painting to originate from {@code JViewport}, or one of its
   * ancestors. Otherwise returns {@code false}.
   *
   * @return true if if scroll mode is a {@code BACKINGSTORE_SCROLL_MODE}.
   * @see JComponent#isPaintingOrigin()
   */
  protected boolean isPaintingOrigin() {
    return scrollMode == BACKINGSTORE_SCROLL_MODE;
  }


  /**
   * Only used by the paint method below.
   */
  private Point getViewLocation() {
    Component view = getView();
    if (view != null) {
      return view.getLocation();
    } else {
      return new Point(0, 0);
    }
  }

  /**
   * Depending on whether the <code>backingStore</code> is enabled,
   * either paint the image through the backing store or paint
   * just the recently exposed part, using the backing store
   * to "blit" the remainder.
   * <blockquote>
   * The term "blit" is the pronounced version of the PDP-10
   * BLT (BLock Transfer) instruction, which copied a block of
   * bits. (In case you were curious.)
   * </blockquote>
   *
   * @param g the <code>Graphics</code> context within which to paint
   */
  public void paint(Graphics g) {
    int width = getWidth();
    int height = getHeight();

    if ((width <= 0) || (height <= 0)) {
      return;
    }

    if (inBlitPaint) {
      // We invoked paint as part of copyArea cleanup, let it through.
      super.paint(g);
      return;
    }

    if (repaintAll) {
      repaintAll = false;
      Rectangle clipB = g.getClipBounds();
      if (clipB.width < getWidth() ||
          clipB.height < getHeight()) {
        waitingForRepaint = true;
        if (repaintTimer == null) {
          repaintTimer = createRepaintTimer();
        }
        repaintTimer.stop();
        repaintTimer.start();
        // We really don't need to paint, a future repaint will
        // take care of it, but if we don't we get an ugly flicker.
      } else {
        if (repaintTimer != null) {
          repaintTimer.stop();
        }
        waitingForRepaint = false;
      }
    } else if (waitingForRepaint) {
      // Need a complete repaint before resetting waitingForRepaint
      Rectangle clipB = g.getClipBounds();
      if (clipB.width >= getWidth() &&
          clipB.height >= getHeight()) {
        waitingForRepaint = false;
        repaintTimer.stop();
      }
    }

    if (!backingStore || isBlitting() || getView() == null) {
      super.paint(g);
      lastPaintPosition = getViewLocation();
      return;
    }

    // If the view is smaller than the viewport and we are not opaque
    // (that is, we won't paint our background), we should set the
    // clip. Otherwise, as the bounds of the view vary, we will
    // blit garbage into the exposed areas.
    Rectangle viewBounds = getView().getBounds();
    if (!isOpaque()) {
      g.clipRect(0, 0, viewBounds.width, viewBounds.height);
    }

    if (backingStoreImage == null) {
      // Backing store is enabled but this is the first call to paint.
      // Create the backing store, paint it and then copy to g.
      // The backing store image will be created with the size of
      // the viewport. We must make sure the clip region is the
      // same size, otherwise when scrolling the backing image
      // the region outside of the clipped region will not be painted,
      // and result in empty areas.
      backingStoreImage = createImage(width, height);
      Rectangle clip = g.getClipBounds();
      if (clip.width != width || clip.height != height) {
        if (!isOpaque()) {
          g.setClip(0, 0, Math.min(viewBounds.width, width),
              Math.min(viewBounds.height, height));
        } else {
          g.setClip(0, 0, width, height);
        }
        paintViaBackingStore(g, clip);
      } else {
        paintViaBackingStore(g);
      }
    } else {
      if (!scrollUnderway || lastPaintPosition.equals(getViewLocation())) {
        // No scrolling happened: repaint required area via backing store.
        paintViaBackingStore(g);
      } else {
        // The image was scrolled. Manipulate the backing store and flush it to g.
        Point blitFrom = new Point();
        Point blitTo = new Point();
        Dimension blitSize = new Dimension();
        Rectangle blitPaint = new Rectangle();

        Point newLocation = getViewLocation();
        int dx = newLocation.x - lastPaintPosition.x;
        int dy = newLocation.y - lastPaintPosition.y;
        boolean canBlit = computeBlit(dx, dy, blitFrom, blitTo, blitSize, blitPaint);
        if (!canBlit) {
          // The image was either moved diagonally or
          // moved by more than the image size: paint normally.
          paintViaBackingStore(g);
        } else {
          int bdx = blitTo.x - blitFrom.x;
          int bdy = blitTo.y - blitFrom.y;

          // Move the relevant part of the backing store.
          Rectangle clip = g.getClipBounds();
          // We don't want to inherit the clip region when copying
          // bits, if it is inherited it will result in not moving
          // all of the image resulting in garbage appearing on
          // the screen.
          g.setClip(0, 0, width, height);
          Graphics bsg = getBackingStoreGraphics(g);
          try {
            bsg.copyArea(blitFrom.x, blitFrom.y, blitSize.width, blitSize.height, bdx, bdy);

            g.setClip(clip.x, clip.y, clip.width, clip.height);
            // Paint the rest of the view; the part that has just been exposed.
            Rectangle r = viewBounds.intersection(blitPaint);
            bsg.setClip(r);
            super.paint(bsg);

            // Copy whole of the backing store to g.
            g.drawImage(backingStoreImage, 0, 0, this);
          } finally {
            bsg.dispose();
          }
        }
      }
    }
    lastPaintPosition = getViewLocation();
    scrollUnderway = false;
  }


  /**
   * Sets the bounds of this viewport.  If the viewport's width
   * or height has changed, fire a <code>StateChanged</code> event.
   *
   * @param x left edge of the origin
   * @param y top edge of the origin
   * @param w width in pixels
   * @param h height in pixels
   * @see JComponent#reshape(int, int, int, int)
   */
  public void reshape(int x, int y, int w, int h) {
    boolean sizeChanged = (getWidth() != w) || (getHeight() != h);
    if (sizeChanged) {
      backingStoreImage = null;
    }
    super.reshape(x, y, w, h);
    if (sizeChanged || viewChanged) {
      viewChanged = false;

      fireStateChanged();
    }
  }


  /**
   * Used to control the method of scrolling the viewport contents.
   * You may want to change this mode to get maximum performance for your
   * use case.
   *
   * @param mode one of the following values: <ul> <li> JViewport.BLIT_SCROLL_MODE <li>
   * JViewport.BACKINGSTORE_SCROLL_MODE <li> JViewport.SIMPLE_SCROLL_MODE </ul>
   * @beaninfo bound: false description: Method of moving contents for incremental scrolls. enum:
   * BLIT_SCROLL_MODE JViewport.BLIT_SCROLL_MODE BACKINGSTORE_SCROLL_MODE
   * JViewport.BACKINGSTORE_SCROLL_MODE SIMPLE_SCROLL_MODE JViewport.SIMPLE_SCROLL_MODE
   * @see #BLIT_SCROLL_MODE
   * @see #BACKINGSTORE_SCROLL_MODE
   * @see #SIMPLE_SCROLL_MODE
   * @since 1.3
   */
  public void setScrollMode(int mode) {
    scrollMode = mode;
    backingStore = mode == BACKINGSTORE_SCROLL_MODE;
  }

  /**
   * Returns the current scrolling mode.
   *
   * @return the <code>scrollMode</code> property
   * @see #setScrollMode
   * @since 1.3
   */
  public int getScrollMode() {
    return scrollMode;
  }

  /**
   * Returns <code>true</code> if this viewport is maintaining
   * an offscreen image of its contents.
   *
   * @return <code>true</code> if <code>scrollMode</code> is <code>BACKINGSTORE_SCROLL_MODE</code>
   * @deprecated As of Java 2 platform v1.3, replaced by <code>getScrollMode()</code>.
   */
  @Deprecated
  public boolean isBackingStoreEnabled() {
    return scrollMode == BACKINGSTORE_SCROLL_MODE;
  }


  /**
   * If true if this viewport will maintain an offscreen
   * image of its contents.  The image is used to reduce the cost
   * of small one dimensional changes to the <code>viewPosition</code>.
   * Rather than repainting the entire viewport we use
   * <code>Graphics.copyArea</code> to effect some of the scroll.
   *
   * @param enabled if true, maintain an offscreen backing store
   * @deprecated As of Java 2 platform v1.3, replaced by <code>setScrollMode()</code>.
   */
  @Deprecated
  public void setBackingStoreEnabled(boolean enabled) {
    if (enabled) {
      setScrollMode(BACKINGSTORE_SCROLL_MODE);
    } else {
      setScrollMode(BLIT_SCROLL_MODE);
    }
  }

  private boolean isBlitting() {
    Component view = getView();
    return (scrollMode == BLIT_SCROLL_MODE) &&
        (view instanceof JComponent) && view.isOpaque();
  }


  /**
   * Returns the <code>JViewport</code>'s one child or <code>null</code>.
   *
   * @return the viewports child, or <code>null</code> if none exists
   * @see #setView
   */
  public Component getView() {
    return (getComponentCount() > 0) ? getComponent(0) : null;
  }

  /**
   * Sets the <code>JViewport</code>'s one lightweight child
   * (<code>view</code>), which can be <code>null</code>.
   *
   * @param view the viewport's new lightweight child
   * @see #getView
   */
  public void setView(Component view) {

        /* Remove the viewport's existing children, if any.
         * Note that removeAll() isn't used here because it
         * doesn't call remove() (which JViewport overrides).
         */
    int n = getComponentCount();
    for (int i = n - 1; i >= 0; i--) {
      remove(getComponent(i));
    }

    isViewSizeSet = false;

    if (view != null) {
      super.addImpl(view, null, -1);
      viewListener = createViewListener();
      view.addComponentListener(viewListener);
    }

    if (hasHadValidView) {
      // Only fire a change if a view has been installed.
      fireStateChanged();
    } else if (view != null) {
      hasHadValidView = true;
    }

    viewChanged = true;

    revalidate();
    repaint();
  }


  /**
   * If the view's size hasn't been explicitly set, return the
   * preferred size, otherwise return the view's current size.
   * If there is no view, return 0,0.
   *
   * @return a <code>Dimension</code> object specifying the size of the view
   */
  public Dimension getViewSize() {
    Component view = getView();

    if (view == null) {
      return new Dimension(0, 0);
    } else if (isViewSizeSet) {
      return view.getSize();
    } else {
      return view.getPreferredSize();
    }
  }


  /**
   * Sets the size of the view.  A state changed event will be fired.
   *
   * @param newSize a <code>Dimension</code> object specifying the new size of the view
   */
  public void setViewSize(Dimension newSize) {
    Component view = getView();
    if (view != null) {
      Dimension oldSize = view.getSize();
      if (!newSize.equals(oldSize)) {
        // scrollUnderway will be true if this is invoked as the
        // result of a validate and setViewPosition was previously
        // invoked.
        scrollUnderway = false;
        view.setSize(newSize);
        isViewSizeSet = true;
        fireStateChanged();
      }
    }
  }

  /**
   * Returns the view coordinates that appear in the upper left
   * hand corner of the viewport, or 0,0 if there's no view.
   *
   * @return a <code>Point</code> object giving the upper left coordinates
   */
  public Point getViewPosition() {
    Component view = getView();
    if (view != null) {
      Point p = view.getLocation();
      p.x = -p.x;
      p.y = -p.y;
      return p;
    } else {
      return new Point(0, 0);
    }
  }


  /**
   * Sets the view coordinates that appear in the upper left
   * hand corner of the viewport, does nothing if there's no view.
   *
   * @param p a <code>Point</code> object giving the upper left coordinates
   */
  public void setViewPosition(Point p) {
    Component view = getView();
    if (view == null) {
      return;
    }

    int oldX, oldY, x = p.x, y = p.y;

        /* Collect the old x,y values for the views location
         * and do the song and dance to avoid allocating
         * a Rectangle object if we don't have to.
         */
    if (view instanceof JComponent) {
      JComponent c = (JComponent) view;
      oldX = c.getX();
      oldY = c.getY();
    } else {
      Rectangle r = view.getBounds();
      oldX = r.x;
      oldY = r.y;
    }

        /* The view scrolls in the opposite direction to mouse
         * movement.
         */
    int newX = -x;
    int newY = -y;

    if ((oldX != newX) || (oldY != newY)) {
      if (!waitingForRepaint && isBlitting() && canUseWindowBlitter()) {
        RepaintManager rm = RepaintManager.currentManager(this);
        // The cast to JComponent will work, if view is not
        // a JComponent, isBlitting will return false.
        JComponent jview = (JComponent) view;
        Rectangle dirty = rm.getDirtyRegion(jview);
        if (dirty == null || !dirty.contains(jview.getVisibleRect())) {
          rm.beginPaint();
          try {
            Graphics g = JComponent.safelyGetGraphics(this);
            flushViewDirtyRegion(g, dirty);
            view.setLocation(newX, newY);
            Rectangle r = new Rectangle(
                0, 0, getWidth(), Math.min(getHeight(), jview.getHeight()));
            g.setClip(r);
            // Repaint the complete component if the blit succeeded
            // and needsRepaintAfterBlit returns true.
            repaintAll = (windowBlitPaint(g) &&
                needsRepaintAfterBlit());
            g.dispose();
            rm.notifyRepaintPerformed(this, r.x, r.y, r.width, r.height);
            rm.markCompletelyClean((JComponent) getParent());
            rm.markCompletelyClean(this);
            rm.markCompletelyClean(jview);
          } finally {
            rm.endPaint();
          }
        } else {
          // The visible region is dirty, no point in doing copyArea
          view.setLocation(newX, newY);
          repaintAll = false;
        }
      } else {
        scrollUnderway = true;
        // This calls setBounds(), and then repaint().
        view.setLocation(newX, newY);
        repaintAll = false;
      }
      // we must validate the hierarchy to not break the hw/lw mixing
      revalidate();
      fireStateChanged();
    }
  }


  /**
   * Returns a rectangle whose origin is <code>getViewPosition</code>
   * and size is <code>getExtentSize</code>.
   * This is the visible part of the view, in view coordinates.
   *
   * @return a <code>Rectangle</code> giving the visible part of the view using view coordinates.
   */
  public Rectangle getViewRect() {
    return new Rectangle(getViewPosition(), getExtentSize());
  }


  /**
   * Computes the parameters for a blit where the backing store image
   * currently contains <code>oldLoc</code> in the upper left hand corner
   * and we're scrolling to <code>newLoc</code>.
   * The parameters are modified
   * to return the values required for the blit.
   *
   * @param dx the horizontal delta
   * @param dy the vertical delta
   * @param blitFrom the <code>Point</code> we're blitting from
   * @param blitTo the <code>Point</code> we're blitting to
   * @param blitSize the <code>Dimension</code> of the area to blit
   * @param blitPaint the area to blit
   * @return true if the parameters are modified and we're ready to blit; false otherwise
   */
  protected boolean computeBlit(
      int dx,
      int dy,
      Point blitFrom,
      Point blitTo,
      Dimension blitSize,
      Rectangle blitPaint) {
    int dxAbs = Math.abs(dx);
    int dyAbs = Math.abs(dy);
    Dimension extentSize = getExtentSize();

    if ((dx == 0) && (dy != 0) && (dyAbs < extentSize.height)) {
      if (dy < 0) {
        blitFrom.y = -dy;
        blitTo.y = 0;
        blitPaint.y = extentSize.height + dy;
      } else {
        blitFrom.y = 0;
        blitTo.y = dy;
        blitPaint.y = 0;
      }

      blitPaint.x = blitFrom.x = blitTo.x = 0;

      blitSize.width = extentSize.width;
      blitSize.height = extentSize.height - dyAbs;

      blitPaint.width = extentSize.width;
      blitPaint.height = dyAbs;

      return true;
    } else if ((dy == 0) && (dx != 0) && (dxAbs < extentSize.width)) {
      if (dx < 0) {
        blitFrom.x = -dx;
        blitTo.x = 0;
        blitPaint.x = extentSize.width + dx;
      } else {
        blitFrom.x = 0;
        blitTo.x = dx;
        blitPaint.x = 0;
      }

      blitPaint.y = blitFrom.y = blitTo.y = 0;

      blitSize.width = extentSize.width - dxAbs;
      blitSize.height = extentSize.height;

      blitPaint.width = dxAbs;
      blitPaint.height = extentSize.height;

      return true;
    } else {
      return false;
    }
  }


  /**
   * Returns the size of the visible part of the view in view coordinates.
   *
   * @return a <code>Dimension</code> object giving the size of the view
   */
  @Transient
  public Dimension getExtentSize() {
    return getSize();
  }


  /**
   * Converts a size in pixel coordinates to view coordinates.
   * Subclasses of viewport that support "logical coordinates"
   * will override this method.
   *
   * @param size a <code>Dimension</code> object using pixel coordinates
   * @return a <code>Dimension</code> object converted to view coordinates
   */
  public Dimension toViewCoordinates(Dimension size) {
    return new Dimension(size);
  }

  /**
   * Converts a point in pixel coordinates to view coordinates.
   * Subclasses of viewport that support "logical coordinates"
   * will override this method.
   *
   * @param p a <code>Point</code> object using pixel coordinates
   * @return a <code>Point</code> object converted to view coordinates
   */
  public Point toViewCoordinates(Point p) {
    return new Point(p);
  }


  /**
   * Sets the size of the visible part of the view using view coordinates.
   *
   * @param newExtent a <code>Dimension</code> object specifying the size of the view
   */
  public void setExtentSize(Dimension newExtent) {
    Dimension oldExtent = getExtentSize();
    if (!newExtent.equals(oldExtent)) {
      setSize(newExtent);
      fireStateChanged();
    }
  }

  /**
   * A listener for the view.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  protected class ViewListener extends ComponentAdapter implements Serializable {

    public void componentResized(ComponentEvent e) {
      fireStateChanged();
      revalidate();
    }
  }

  /**
   * Creates a listener for the view.
   *
   * @return a <code>ViewListener</code>
   */
  protected ViewListener createViewListener() {
    return new ViewListener();
  }


  /**
   * Subclassers can override this to install a different
   * layout manager (or <code>null</code>) in the constructor.  Returns
   * the <code>LayoutManager</code> to install on the <code>JViewport</code>.
   *
   * @return a <code>LayoutManager</code>
   */
  protected LayoutManager createLayoutManager() {
    return ViewportLayout.SHARED_INSTANCE;
  }


  /**
   * Adds a <code>ChangeListener</code> to the list that is
   * notified each time the view's
   * size, position, or the viewport's extent size has changed.
   *
   * @param l the <code>ChangeListener</code> to add
   * @see #removeChangeListener
   * @see #setViewPosition
   * @see #setViewSize
   * @see #setExtentSize
   */
  public void addChangeListener(ChangeListener l) {
    listenerList.add(ChangeListener.class, l);
  }

  /**
   * Removes a <code>ChangeListener</code> from the list that's notified each
   * time the views size, position, or the viewports extent size
   * has changed.
   *
   * @param l the <code>ChangeListener</code> to remove
   * @see #addChangeListener
   */
  public void removeChangeListener(ChangeListener l) {
    listenerList.remove(ChangeListener.class, l);
  }

  /**
   * Returns an array of all the <code>ChangeListener</code>s added
   * to this JViewport with addChangeListener().
   *
   * @return all of the <code>ChangeListener</code>s added or an empty array if no listeners have
   * been added
   * @since 1.4
   */
  public ChangeListener[] getChangeListeners() {
    return listenerList.getListeners(ChangeListener.class);
  }

  /**
   * Notifies all <code>ChangeListeners</code> when the views
   * size, position, or the viewports extent size has changed.
   *
   * @see #addChangeListener
   * @see #removeChangeListener
   * @see EventListenerList
   */
  protected void fireStateChanged() {
    Object[] listeners = listenerList.getListenerList();
    for (int i = listeners.length - 2; i >= 0; i -= 2) {
      if (listeners[i] == ChangeListener.class) {
        if (changeEvent == null) {
          changeEvent = new ChangeEvent(this);
        }
        ((ChangeListener) listeners[i + 1]).stateChanged(changeEvent);
      }
    }
  }

  /**
   * Always repaint in the parents coordinate system to make sure
   * only one paint is performed by the <code>RepaintManager</code>.
   *
   * @param tm maximum time in milliseconds before update
   * @param x the <code>x</code> coordinate (pixels over from left)
   * @param y the <code>y</code> coordinate (pixels down from top)
   * @param w the width
   * @param h the height
   * @see java.awt.Component#update(java.awt.Graphics)
   */
  public void repaint(long tm, int x, int y, int w, int h) {
    Container parent = getParent();
    if (parent != null) {
      parent.repaint(tm, x + getX(), y + getY(), w, h);
    } else {
      super.repaint(tm, x, y, w, h);
    }
  }


  /**
   * Returns a string representation of this <code>JViewport</code>.
   * This method
   * is intended to be used only for debugging purposes, and the
   * content and format of the returned string may vary between
   * implementations. The returned string may be empty but may not
   * be <code>null</code>.
   *
   * @return a string representation of this <code>JViewport</code>
   */
  protected String paramString() {
    String isViewSizeSetString = (isViewSizeSet ?
        "true" : "false");
    String lastPaintPositionString = (lastPaintPosition != null ?
        lastPaintPosition.toString() : "");
    String scrollUnderwayString = (scrollUnderway ?
        "true" : "false");

    return super.paramString() +
        ",isViewSizeSet=" + isViewSizeSetString +
        ",lastPaintPosition=" + lastPaintPositionString +
        ",scrollUnderway=" + scrollUnderwayString;
  }

  //
  // Following is used when doBlit is true.
  //

  /**
   * Notifies listeners of a property change. This is subclassed to update
   * the <code>windowBlit</code> property.
   * (The <code>putClientProperty</code> property is final).
   *
   * @param propertyName a string containing the property name
   * @param oldValue the old value of the property
   * @param newValue the new value of the property
   */
  protected void firePropertyChange(String propertyName, Object oldValue,
      Object newValue) {
    super.firePropertyChange(propertyName, oldValue, newValue);
    if (propertyName.equals(EnableWindowBlit)) {
      if (newValue != null) {
        setScrollMode(BLIT_SCROLL_MODE);
      } else {
        setScrollMode(SIMPLE_SCROLL_MODE);
      }
    }
  }

  /**
   * Returns true if the component needs to be completely repainted after
   * a blit and a paint is received.
   */
  private boolean needsRepaintAfterBlit() {
    // Find the first heavy weight ancestor. isObscured and
    // canDetermineObscurity are only appropriate for heavy weights.
    Component heavyParent = getParent();

    while (heavyParent != null && heavyParent.isLightweight()) {
      heavyParent = heavyParent.getParent();
    }

    if (heavyParent != null) {
      ComponentPeer peer = heavyParent.getPeer();

      if (peer != null && peer.canDetermineObscurity() &&
          !peer.isObscured()) {
        // The peer says we aren't obscured, therefore we can assume
        // that we won't later be messaged to paint a portion that
        // we tried to blit that wasn't valid.
        // It is certainly possible that when we blited we were
        // obscured, and by the time this is invoked we aren't, but the
        // chances of that happening are pretty slim.
        return false;
      }
    }
    return true;
  }

  private Timer createRepaintTimer() {
    Timer timer = new Timer(300, new ActionListener() {
      public void actionPerformed(ActionEvent ae) {
        // waitingForRepaint will be false if a paint came down
        // with the complete clip rect, in which case we don't
        // have to cause a repaint.
        if (waitingForRepaint) {
          repaint();
        }
      }
    });
    timer.setRepeats(false);
    return timer;
  }

  /**
   * If the repaint manager has a dirty region for the view, the view is
   * asked to paint.
   *
   * @param g the <code>Graphics</code> context within which to paint
   */
  private void flushViewDirtyRegion(Graphics g, Rectangle dirty) {
    JComponent view = (JComponent) getView();
    if (dirty != null && dirty.width > 0 && dirty.height > 0) {
      dirty.x += view.getX();
      dirty.y += view.getY();
      Rectangle clip = g.getClipBounds();
      if (clip == null) {
        // Only happens in 1.2
        g.setClip(0, 0, getWidth(), getHeight());
      }
      g.clipRect(dirty.x, dirty.y, dirty.width, dirty.height);
      clip = g.getClipBounds();
      // Only paint the dirty region if it is visible.
      if (clip.width > 0 && clip.height > 0) {
        paintView(g);
      }
    }
  }

  /**
   * Used when blitting.
   *
   * @param g the <code>Graphics</code> context within which to paint
   * @return true if blitting succeeded; otherwise false
   */
  private boolean windowBlitPaint(Graphics g) {
    int width = getWidth();
    int height = getHeight();

    if ((width == 0) || (height == 0)) {
      return false;
    }

    boolean retValue;
    RepaintManager rm = RepaintManager.currentManager(this);
    JComponent view = (JComponent) getView();

    if (lastPaintPosition == null ||
        lastPaintPosition.equals(getViewLocation())) {
      paintView(g);
      retValue = false;
    } else {
      // The image was scrolled. Manipulate the backing store and flush
      // it to g.
      Point blitFrom = new Point();
      Point blitTo = new Point();
      Dimension blitSize = new Dimension();
      Rectangle blitPaint = new Rectangle();

      Point newLocation = getViewLocation();
      int dx = newLocation.x - lastPaintPosition.x;
      int dy = newLocation.y - lastPaintPosition.y;
      boolean canBlit = computeBlit(dx, dy, blitFrom, blitTo, blitSize,
          blitPaint);
      if (!canBlit) {
        paintView(g);
        retValue = false;
      } else {
        // Prepare the rest of the view; the part that has just been
        // exposed.
        Rectangle r = view.getBounds().intersection(blitPaint);
        r.x -= view.getX();
        r.y -= view.getY();

        blitDoubleBuffered(view, g, r.x, r.y, r.width, r.height,
            blitFrom.x, blitFrom.y, blitTo.x, blitTo.y,
            blitSize.width, blitSize.height);
        retValue = true;
      }
    }
    lastPaintPosition = getViewLocation();
    return retValue;
  }

  //
  // NOTE: the code below uses paintForceDoubleBuffered for historical
  // reasons.  If we're going to allow a blit we've already accounted for
  // everything that paintImmediately and _paintImmediately does, for that
  // reason we call into paintForceDoubleBuffered to diregard whether or
  // not setDoubleBuffered(true) was invoked on the view.
  //

  private void blitDoubleBuffered(JComponent view, Graphics g,
      int clipX, int clipY, int clipW, int clipH,
      int blitFromX, int blitFromY, int blitToX, int blitToY,
      int blitW, int blitH) {
    // NOTE:
    //   blitFrom/blitTo are in JViewport coordinates system
    //     not the views coordinate space.
    //   clip* are in the views coordinate space.
    RepaintManager rm = RepaintManager.currentManager(this);
    int bdx = blitToX - blitFromX;
    int bdy = blitToY - blitFromY;

    Composite oldComposite = null;
    // Shift the scrolled region
    if (g instanceof Graphics2D) {
      Graphics2D g2d = (Graphics2D) g;
      oldComposite = g2d.getComposite();
      g2d.setComposite(AlphaComposite.Src);
    }
    rm.copyArea(this, g, blitFromX, blitFromY, blitW, blitH, bdx, bdy,
        false);
    if (oldComposite != null) {
      ((Graphics2D) g).setComposite(oldComposite);
    }
    // Paint the newly exposed region.
    int x = view.getX();
    int y = view.getY();
    g.translate(x, y);
    g.setClip(clipX, clipY, clipW, clipH);
    view.paintForceDoubleBuffered(g);
    g.translate(-x, -y);
  }

  /**
   * Called to paint the view, usually when <code>blitPaint</code>
   * can not blit.
   *
   * @param g the <code>Graphics</code> context within which to paint
   */
  private void paintView(Graphics g) {
    Rectangle clip = g.getClipBounds();
    JComponent view = (JComponent) getView();

    if (view.getWidth() >= getWidth()) {
      // Graphics is relative to JViewport, need to map to view's
      // coordinates space.
      int x = view.getX();
      int y = view.getY();
      g.translate(x, y);
      g.setClip(clip.x - x, clip.y - y, clip.width, clip.height);
      view.paintForceDoubleBuffered(g);
      g.translate(-x, -y);
      g.setClip(clip.x, clip.y, clip.width, clip.height);
    } else {
      // To avoid any problems that may result from the viewport being
      // bigger than the view we start painting from the viewport.
      try {
        inBlitPaint = true;
        paintForceDoubleBuffered(g);
      } finally {
        inBlitPaint = false;
      }
    }
  }

  /**
   * Returns true if the viewport is not obscured by one of its ancestors,
   * or its ancestors children and if the viewport is showing. Blitting
   * when the view isn't showing will work,
   * or rather <code>copyArea</code> will work,
   * but will not produce the expected behavior.
   */
  private boolean canUseWindowBlitter() {
    if (!isShowing() || (!(getParent() instanceof JComponent) &&
        !(getView() instanceof JComponent))) {
      return false;
    }
    if (isPainting()) {
      // We're in the process of painting, don't blit. If we were
      // to blit we would draw on top of what we're already drawing,
      // so bail.
      return false;
    }

    Rectangle dirtyRegion = RepaintManager.currentManager(this).
        getDirtyRegion((JComponent) getParent());

    if (dirtyRegion != null && dirtyRegion.width > 0 &&
        dirtyRegion.height > 0) {
      // Part of the scrollpane needs to be repainted too, don't blit.
      return false;
    }

    Rectangle clip = new Rectangle(0, 0, getWidth(), getHeight());
    Rectangle oldClip = new Rectangle();
    Rectangle tmp2 = null;
    Container parent;
    Component lastParent = null;
    int x, y, w, h;

    for (parent = this; parent != null && isLightweightComponent(parent);
        parent = parent.getParent()) {
      x = parent.getX();
      y = parent.getY();
      w = parent.getWidth();
      h = parent.getHeight();

      oldClip.setBounds(clip);
      SwingUtilities.computeIntersection(0, 0, w, h, clip);
      if (!clip.equals(oldClip)) {
        return false;
      }

      if (lastParent != null && parent instanceof JComponent &&
          !((JComponent) parent).isOptimizedDrawingEnabled()) {
        Component comps[] = parent.getComponents();
        int index = 0;

        for (int i = comps.length - 1; i >= 0; i--) {
          if (comps[i] == lastParent) {
            index = i - 1;
            break;
          }
        }

        while (index >= 0) {
          tmp2 = comps[index].getBounds(tmp2);

          if (tmp2.intersects(clip)) {
            return false;
          }
          index--;
        }
      }
      clip.x += x;
      clip.y += y;
      lastParent = parent;
    }
    if (parent == null) {
      // No Window parent.
      return false;
    }
    return true;
  }

/////////////////
// Accessibility support
////////////////

  /**
   * Gets the AccessibleContext associated with this JViewport.
   * For viewports, the AccessibleContext takes the form of an
   * AccessibleJViewport.
   * A new AccessibleJViewport instance is created if necessary.
   *
   * @return an AccessibleJViewport that serves as the AccessibleContext of this JViewport
   */
  public AccessibleContext getAccessibleContext() {
    if (accessibleContext == null) {
      accessibleContext = new AccessibleJViewport();
    }
    return accessibleContext;
  }

  /**
   * This class implements accessibility support for the
   * <code>JViewport</code> class.  It provides an implementation of the
   * Java Accessibility API appropriate to viewport user-interface elements.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  protected class AccessibleJViewport extends AccessibleJComponent {

    /**
     * Get the role of this object.
     *
     * @return an instance of AccessibleRole describing the role of the object
     */
    public AccessibleRole getAccessibleRole() {
      return AccessibleRole.VIEWPORT;
    }
  } // inner class AccessibleJViewport
}
